home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / BORLAND TURBO / RTLWIN32.PAK / WINSVC.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  18.7 KB  |  754 lines
  1. /*++ BUILD Version: 0010    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1995  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     winsvc.h
  8.  
  9. Abstract:
  10.  
  11.     Header file for the Service Control Manager
  12.  
  13. Environment:
  14.  
  15.     User Mode - Win32
  16.  
  17. --*/
  18. #ifndef _WINSVC_
  19. #define _WINSVC_
  20. #pragma option -b
  21.  
  22. //
  23. // Define API decoration for direct importing of DLL references.
  24. //
  25.  
  26. #if !defined(WINADVAPI)
  27. #if !defined(_ADVAPI32_)
  28. #define WINADVAPI DECLSPEC_IMPORT
  29. #else
  30. #define WINADVAPI
  31. #endif
  32. #endif
  33.  
  34. #ifdef __cplusplus
  35. extern "C" {
  36. #endif
  37.  
  38. //
  39. // Constants
  40. //
  41.  
  42. //
  43. // Service database names
  44. //
  45.  
  46. #define SERVICES_ACTIVE_DATABASEW      L"ServicesActive"
  47. #define SERVICES_FAILED_DATABASEW      L"ServicesFailed"
  48.  
  49. #define SERVICES_ACTIVE_DATABASEA      "ServicesActive"
  50. #define SERVICES_FAILED_DATABASEA      "ServicesFailed"
  51.  
  52. //
  53. // Character to designate that a name is a group
  54. //
  55.  
  56. #define SC_GROUP_IDENTIFIERW           L'+'
  57. #define SC_GROUP_IDENTIFIERA           '+'
  58.  
  59. #ifdef UNICODE
  60.  
  61. #define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEW
  62. #define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEW
  63.  
  64.  
  65. #define SC_GROUP_IDENTIFIER            SC_GROUP_IDENTIFIERW
  66.  
  67. #else // ndef UNICODE
  68.  
  69. #define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEA
  70. #define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEA
  71.  
  72. #define SC_GROUP_IDENTIFIER            SC_GROUP_IDENTIFIERA
  73. #endif // ndef UNICODE
  74.  
  75.  
  76. //
  77. // Value to indicate no change to an optional parameter
  78. //
  79. #define SERVICE_NO_CHANGE              0xffffffff
  80.  
  81. //
  82. // Service State -- for Enum Requests (Bit Mask)
  83. //
  84. #define SERVICE_ACTIVE                 0x00000001
  85. #define SERVICE_INACTIVE               0x00000002
  86. #define SERVICE_STATE_ALL              (SERVICE_ACTIVE   | \
  87.                                         SERVICE_INACTIVE)
  88.  
  89. //
  90. // Controls
  91. //
  92. #define SERVICE_CONTROL_STOP           0x00000001
  93. #define SERVICE_CONTROL_PAUSE          0x00000002
  94. #define SERVICE_CONTROL_CONTINUE       0x00000003
  95. #define SERVICE_CONTROL_INTERROGATE    0x00000004
  96. #define SERVICE_CONTROL_SHUTDOWN       0x00000005
  97.  
  98. //
  99. // Service State -- for CurrentState
  100. //
  101. #define SERVICE_STOPPED                0x00000001
  102. #define SERVICE_START_PENDING          0x00000002
  103. #define SERVICE_STOP_PENDING           0x00000003
  104. #define SERVICE_RUNNING                0x00000004
  105. #define SERVICE_CONTINUE_PENDING       0x00000005
  106. #define SERVICE_PAUSE_PENDING          0x00000006
  107. #define SERVICE_PAUSED                 0x00000007
  108.  
  109. //
  110. // Controls Accepted  (Bit Mask)
  111. //
  112. #define SERVICE_ACCEPT_STOP            0x00000001
  113. #define SERVICE_ACCEPT_PAUSE_CONTINUE  0x00000002
  114. #define SERVICE_ACCEPT_SHUTDOWN        0x00000004
  115.  
  116. //
  117. // Service Control Manager object specific access types
  118. //
  119. #define SC_MANAGER_CONNECT             0x0001
  120. #define SC_MANAGER_CREATE_SERVICE      0x0002
  121. #define SC_MANAGER_ENUMERATE_SERVICE   0x0004
  122. #define SC_MANAGER_LOCK                0x0008
  123. #define SC_MANAGER_QUERY_LOCK_STATUS   0x0010
  124. #define SC_MANAGER_MODIFY_BOOT_CONFIG  0x0020
  125.  
  126. #define SC_MANAGER_ALL_ACCESS          (STANDARD_RIGHTS_REQUIRED      | \
  127.                                         SC_MANAGER_CONNECT            | \
  128.                                         SC_MANAGER_CREATE_SERVICE     | \
  129.                                         SC_MANAGER_ENUMERATE_SERVICE  | \
  130.                                         SC_MANAGER_LOCK               | \
  131.                                         SC_MANAGER_QUERY_LOCK_STATUS  | \
  132.                                         SC_MANAGER_MODIFY_BOOT_CONFIG)
  133.  
  134.  
  135.  
  136. //
  137. // Service object specific access type
  138. //
  139. #define SERVICE_QUERY_CONFIG           0x0001
  140. #define SERVICE_CHANGE_CONFIG          0x0002
  141. #define SERVICE_QUERY_STATUS           0x0004
  142. #define SERVICE_ENUMERATE_DEPENDENTS   0x0008
  143. #define SERVICE_START                  0x0010
  144. #define SERVICE_STOP                   0x0020
  145. #define SERVICE_PAUSE_CONTINUE         0x0040
  146. #define SERVICE_INTERROGATE            0x0080
  147. #define SERVICE_USER_DEFINED_CONTROL   0x0100
  148.  
  149. #define SERVICE_ALL_ACCESS             (STANDARD_RIGHTS_REQUIRED     | \
  150.                                         SERVICE_QUERY_CONFIG         | \
  151.                                         SERVICE_CHANGE_CONFIG        | \
  152.                                         SERVICE_QUERY_STATUS         | \
  153.                                         SERVICE_ENUMERATE_DEPENDENTS | \
  154.                                         SERVICE_START                | \
  155.                                         SERVICE_STOP                 | \
  156.                                         SERVICE_PAUSE_CONTINUE       | \
  157.                                         SERVICE_INTERROGATE          | \
  158.                                         SERVICE_USER_DEFINED_CONTROL)
  159.  
  160.  
  161. //
  162. // Handle Types
  163. //
  164.  
  165. typedef HANDLE      SC_HANDLE;
  166. typedef SC_HANDLE   *LPSC_HANDLE;
  167.  
  168. typedef DWORD       SERVICE_STATUS_HANDLE;
  169.  
  170. //
  171. // Service Status Structure
  172. //
  173.  
  174. typedef struct _SERVICE_STATUS {
  175.     DWORD   dwServiceType;
  176.     DWORD   dwCurrentState;
  177.     DWORD   dwControlsAccepted;
  178.     DWORD   dwWin32ExitCode;
  179.     DWORD   dwServiceSpecificExitCode;
  180.     DWORD   dwCheckPoint;
  181.     DWORD   dwWaitHint;
  182. } SERVICE_STATUS, *LPSERVICE_STATUS;
  183.  
  184.  
  185.  
  186. //
  187. // Service Status Enumeration Structure
  188. //
  189.  
  190. typedef struct _ENUM_SERVICE_STATUSA {
  191.     LPSTR          lpServiceName;
  192.     LPSTR          lpDisplayName;
  193.     SERVICE_STATUS ServiceStatus;
  194. } ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA;
  195. typedef struct _ENUM_SERVICE_STATUSW {
  196.     LPWSTR         lpServiceName;
  197.     LPWSTR         lpDisplayName;
  198.     SERVICE_STATUS ServiceStatus;
  199. } ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;
  200. #ifdef UNICODE
  201. typedef ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUS;
  202. typedef LPENUM_SERVICE_STATUSW LPENUM_SERVICE_STATUS;
  203. #else
  204. typedef ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUS;
  205. typedef LPENUM_SERVICE_STATUSA LPENUM_SERVICE_STATUS;
  206. #endif // UNICODE
  207.  
  208.  
  209. //
  210. // Structures for the Lock API functions
  211. //
  212.  
  213. typedef LPVOID  SC_LOCK;
  214.  
  215. typedef struct _QUERY_SERVICE_LOCK_STATUSA {
  216.     DWORD   fIsLocked;
  217.     LPSTR   lpLockOwner;
  218.     DWORD   dwLockDuration;
  219. } QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
  220. typedef struct _QUERY_SERVICE_LOCK_STATUSW {
  221.     DWORD   fIsLocked;
  222.     LPWSTR  lpLockOwner;
  223.     DWORD   dwLockDuration;
  224. } QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;
  225. #ifdef UNICODE
  226. typedef QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUS;
  227. typedef LPQUERY_SERVICE_LOCK_STATUSW LPQUERY_SERVICE_LOCK_STATUS;
  228. #else
  229. typedef QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUS;
  230. typedef LPQUERY_SERVICE_LOCK_STATUSA LPQUERY_SERVICE_LOCK_STATUS;
  231. #endif // UNICODE
  232.  
  233.  
  234.  
  235. //
  236. // Query Service Configuration Structure
  237. //
  238.  
  239. typedef struct _QUERY_SERVICE_CONFIGA {
  240.     DWORD   dwServiceType;
  241.     DWORD   dwStartType;
  242.     DWORD   dwErrorControl;
  243.     LPSTR   lpBinaryPathName;
  244.     LPSTR   lpLoadOrderGroup;
  245.     DWORD   dwTagId;
  246.     LPSTR   lpDependencies;
  247.     LPSTR   lpServiceStartName;
  248.     LPSTR   lpDisplayName;
  249. } QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
  250. typedef struct _QUERY_SERVICE_CONFIGW {
  251.     DWORD   dwServiceType;
  252.     DWORD   dwStartType;
  253.     DWORD   dwErrorControl;
  254.     LPWSTR  lpBinaryPathName;
  255.     LPWSTR  lpLoadOrderGroup;
  256.     DWORD   dwTagId;
  257.     LPWSTR  lpDependencies;
  258.     LPWSTR  lpServiceStartName;
  259.     LPWSTR  lpDisplayName;
  260. } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
  261. #ifdef UNICODE
  262. typedef QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIG;
  263. typedef LPQUERY_SERVICE_CONFIGW LPQUERY_SERVICE_CONFIG;
  264. #else
  265. typedef QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIG;
  266. typedef LPQUERY_SERVICE_CONFIGA LPQUERY_SERVICE_CONFIG;
  267. #endif // UNICODE
  268.  
  269.  
  270.  
  271. //
  272. // Function Prototype for the Service Main Function
  273. //
  274.  
  275. typedef VOID (WINAPI *LPSERVICE_MAIN_FUNCTIONW)(
  276.     DWORD   dwNumServicesArgs,
  277.     LPWSTR  *lpServiceArgVectors
  278.     );
  279.  
  280. typedef VOID (WINAPI *LPSERVICE_MAIN_FUNCTIONA)(
  281.     DWORD   dwNumServicesArgs,
  282.     LPSTR   *lpServiceArgVectors
  283.     );
  284.  
  285. #ifdef UNICODE
  286. #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONW
  287. #else
  288. #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONA
  289. #endif //UNICODE
  290.  
  291.  
  292. //
  293. // Service Start Table
  294. //
  295.  
  296. typedef struct _SERVICE_TABLE_ENTRYA {
  297.     LPSTR                       lpServiceName;
  298.     LPSERVICE_MAIN_FUNCTIONA    lpServiceProc;
  299. }SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
  300. typedef struct _SERVICE_TABLE_ENTRYW {
  301.     LPWSTR                      lpServiceName;
  302.     LPSERVICE_MAIN_FUNCTIONW    lpServiceProc;
  303. }SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
  304. #ifdef UNICODE
  305. typedef SERVICE_TABLE_ENTRYW SERVICE_TABLE_ENTRY;
  306. typedef LPSERVICE_TABLE_ENTRYW LPSERVICE_TABLE_ENTRY;
  307. #else
  308. typedef SERVICE_TABLE_ENTRYA SERVICE_TABLE_ENTRY;
  309. typedef LPSERVICE_TABLE_ENTRYA LPSERVICE_TABLE_ENTRY;
  310. #endif // UNICODE
  311.  
  312. //
  313. // Prototype for the Service Control Handler Function
  314. //
  315.  
  316. typedef VOID (WINAPI *LPHANDLER_FUNCTION)(
  317.     DWORD    dwControl
  318.     );
  319.  
  320.  
  321.  
  322. ///////////////////////////////////////////////////////////////////////////
  323. // API Function Prototypes
  324. ///////////////////////////////////////////////////////////////////////////
  325.  
  326. WINADVAPI
  327. BOOL
  328. WINAPI
  329. ChangeServiceConfigA(
  330.     SC_HANDLE    hService,
  331.     DWORD        dwServiceType,
  332.     DWORD        dwStartType,
  333.     DWORD        dwErrorControl,
  334.     LPCSTR     lpBinaryPathName,
  335.     LPCSTR     lpLoadOrderGroup,
  336.     LPDWORD      lpdwTagId,
  337.     LPCSTR     lpDependencies,
  338.     LPCSTR     lpServiceStartName,
  339.     LPCSTR     lpPassword,
  340.     LPCSTR     lpDisplayName
  341.     );
  342. WINADVAPI
  343. BOOL
  344. WINAPI
  345. ChangeServiceConfigW(
  346.     SC_HANDLE    hService,
  347.     DWORD        dwServiceType,
  348.     DWORD        dwStartType,
  349.     DWORD        dwErrorControl,
  350.     LPCWSTR     lpBinaryPathName,
  351.     LPCWSTR     lpLoadOrderGroup,
  352.     LPDWORD      lpdwTagId,
  353.     LPCWSTR     lpDependencies,
  354.     LPCWSTR     lpServiceStartName,
  355.     LPCWSTR     lpPassword,
  356.     LPCWSTR     lpDisplayName
  357.     );
  358. #ifdef UNICODE
  359. #define ChangeServiceConfig  ChangeServiceConfigW
  360. #else
  361. #define ChangeServiceConfig  ChangeServiceConfigA
  362. #endif // !UNICODE
  363.  
  364. WINADVAPI
  365. BOOL
  366. WINAPI
  367. CloseServiceHandle(
  368.     SC_HANDLE   hSCObject
  369.     );
  370.  
  371. WINADVAPI
  372. BOOL
  373. WINAPI
  374. ControlService(
  375.     SC_HANDLE           hService,
  376.     DWORD               dwControl,
  377.     LPSERVICE_STATUS    lpServiceStatus
  378.     );
  379.  
  380. WINADVAPI
  381. SC_HANDLE
  382. WINAPI
  383. CreateServiceA(
  384.     SC_HANDLE    hSCManager,
  385.     LPCSTR     lpServiceName,
  386.     LPCSTR     lpDisplayName,
  387.     DWORD        dwDesiredAccess,
  388.     DWORD        dwServiceType,
  389.     DWORD        dwStartType,
  390.     DWORD        dwErrorControl,
  391.     LPCSTR     lpBinaryPathName,
  392.     LPCSTR     lpLoadOrderGroup,
  393.     LPDWORD      lpdwTagId,
  394.     LPCSTR     lpDependencies,
  395.     LPCSTR     lpServiceStartName,
  396.     LPCSTR     lpPassword
  397.     );
  398. WINADVAPI
  399. SC_HANDLE
  400. WINAPI
  401. CreateServiceW(
  402.     SC_HANDLE    hSCManager,
  403.     LPCWSTR     lpServiceName,
  404.     LPCWSTR     lpDisplayName,
  405.     DWORD        dwDesiredAccess,
  406.     DWORD        dwServiceType,
  407.     DWORD        dwStartType,
  408.     DWORD        dwErrorControl,
  409.     LPCWSTR     lpBinaryPathName,
  410.     LPCWSTR     lpLoadOrderGroup,
  411.     LPDWORD      lpdwTagId,
  412.     LPCWSTR     lpDependencies,
  413.     LPCWSTR     lpServiceStartName,
  414.     LPCWSTR     lpPassword
  415.     );
  416. #ifdef UNICODE
  417. #define CreateService  CreateServiceW
  418. #else
  419. #define CreateService  CreateServiceA
  420. #endif // !UNICODE
  421.  
  422. WINADVAPI
  423. BOOL
  424. WINAPI
  425. DeleteService(
  426.     SC_HANDLE   hService
  427.     );
  428.  
  429. WINADVAPI
  430. BOOL
  431. WINAPI
  432. EnumDependentServicesA(
  433.     SC_HANDLE               hService,
  434.     DWORD                   dwServiceState,
  435.     LPENUM_SERVICE_STATUSA  lpServices,
  436.     DWORD                   cbBufSize,
  437.     LPDWORD                 pcbBytesNeeded,
  438.     LPDWORD                 lpServicesReturned
  439.     );
  440. WINADVAPI
  441. BOOL
  442. WINAPI
  443. EnumDependentServicesW(
  444.     SC_HANDLE               hService,
  445.     DWORD                   dwServiceState,
  446.     LPENUM_SERVICE_STATUSW  lpServices,
  447.     DWORD                   cbBufSize,
  448.     LPDWORD                 pcbBytesNeeded,
  449.     LPDWORD                 lpServicesReturned
  450.     );
  451. #ifdef UNICODE
  452. #define EnumDependentServices  EnumDependentServicesW
  453. #else
  454. #define EnumDependentServices  EnumDependentServicesA
  455. #endif // !UNICODE
  456.  
  457. WINADVAPI
  458. BOOL
  459. WINAPI
  460. EnumServicesStatusA(
  461.     SC_HANDLE               hSCManager,
  462.     DWORD                   dwServiceType,
  463.     DWORD                   dwServiceState,
  464.     LPENUM_SERVICE_STATUSA  lpServices,
  465.     DWORD                   cbBufSize,
  466.     LPDWORD                 pcbBytesNeeded,
  467.     LPDWORD                 lpServicesReturned,
  468.     LPDWORD                 lpResumeHandle
  469.     );
  470. WINADVAPI
  471. BOOL
  472. WINAPI
  473. EnumServicesStatusW(
  474.     SC_HANDLE               hSCManager,
  475.     DWORD                   dwServiceType,
  476.     DWORD                   dwServiceState,
  477.     LPENUM_SERVICE_STATUSW  lpServices,
  478.     DWORD                   cbBufSize,
  479.     LPDWORD                 pcbBytesNeeded,
  480.     LPDWORD                 lpServicesReturned,
  481.     LPDWORD                 lpResumeHandle
  482.     );
  483. #ifdef UNICODE
  484. #define EnumServicesStatus  EnumServicesStatusW
  485. #else
  486. #define EnumServicesStatus  EnumServicesStatusA
  487. #endif // !UNICODE
  488.  
  489. WINADVAPI
  490. BOOL
  491. WINAPI
  492. GetServiceKeyNameA(
  493.     SC_HANDLE               hSCManager,
  494.     LPCSTR                lpDisplayName,
  495.     LPSTR                 lpServiceName,
  496.     LPDWORD                 lpcchBuffer
  497.     );
  498. WINADVAPI
  499. BOOL
  500. WINAPI
  501. GetServiceKeyNameW(
  502.     SC_HANDLE               hSCManager,
  503.     LPCWSTR                lpDisplayName,
  504.     LPWSTR                 lpServiceName,
  505.     LPDWORD                 lpcchBuffer
  506.     );
  507. #ifdef UNICODE
  508. #define GetServiceKeyName  GetServiceKeyNameW
  509. #else
  510. #define GetServiceKeyName  GetServiceKeyNameA
  511. #endif // !UNICODE
  512.  
  513. WINADVAPI
  514. BOOL
  515. WINAPI
  516. GetServiceDisplayNameA(
  517.     SC_HANDLE               hSCManager,
  518.     LPCSTR                lpServiceName,
  519.     LPSTR                 lpDisplayName,
  520.     LPDWORD                 lpcchBuffer
  521.     );
  522. WINADVAPI
  523. BOOL
  524. WINAPI
  525. GetServiceDisplayNameW(
  526.     SC_HANDLE               hSCManager,
  527.     LPCWSTR                lpServiceName,
  528.     LPWSTR                 lpDisplayName,
  529.     LPDWORD                 lpcchBuffer
  530.     );
  531. #ifdef UNICODE
  532. #define GetServiceDisplayName  GetServiceDisplayNameW
  533. #else
  534. #define GetServiceDisplayName  GetServiceDisplayNameA
  535. #endif // !UNICODE
  536.  
  537. WINADVAPI
  538. SC_LOCK
  539. WINAPI
  540. LockServiceDatabase(
  541.     SC_HANDLE   hSCManager
  542.     );
  543.  
  544. WINADVAPI
  545. BOOL
  546. WINAPI
  547. NotifyBootConfigStatus(
  548.     BOOL     BootAcceptable
  549.     );
  550.  
  551. WINADVAPI
  552. SC_HANDLE
  553. WINAPI
  554. OpenSCManagerA(
  555.     LPCSTR lpMachineName,
  556.     LPCSTR lpDatabaseName,
  557.     DWORD   dwDesiredAccess
  558.     );
  559. WINADVAPI
  560. SC_HANDLE
  561. WINAPI
  562. OpenSCManagerW(
  563.     LPCWSTR lpMachineName,
  564.     LPCWSTR lpDatabaseName,
  565.     DWORD   dwDesiredAccess
  566.     );
  567. #ifdef UNICODE
  568. #define OpenSCManager  OpenSCManagerW
  569. #else
  570. #define OpenSCManager  OpenSCManagerA
  571. #endif // !UNICODE
  572.  
  573. WINADVAPI
  574. SC_HANDLE
  575. WINAPI
  576. OpenServiceA(
  577.     SC_HANDLE   hSCManager,
  578.     LPCSTR    lpServiceName,
  579.     DWORD       dwDesiredAccess
  580.     );
  581. WINADVAPI
  582. SC_HANDLE
  583. WINAPI
  584. OpenServiceW(
  585.     SC_HANDLE   hSCManager,
  586.     LPCWSTR    lpServiceName,
  587.     DWORD       dwDesiredAccess
  588.     );
  589. #ifdef UNICODE
  590. #define OpenService  OpenServiceW
  591. #else
  592. #define OpenService  OpenServiceA
  593. #endif // !UNICODE
  594.  
  595. WINADVAPI
  596. BOOL
  597. WINAPI
  598. QueryServiceConfigA(
  599.     SC_HANDLE               hService,
  600.     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
  601.     DWORD                   cbBufSize,
  602.     LPDWORD                 pcbBytesNeeded
  603.     );
  604. WINADVAPI
  605. BOOL
  606. WINAPI
  607. QueryServiceConfigW(
  608.     SC_HANDLE               hService,
  609.     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
  610.     DWORD                   cbBufSize,
  611.     LPDWORD                 pcbBytesNeeded
  612.     );
  613. #ifdef UNICODE
  614. #define QueryServiceConfig  QueryServiceConfigW
  615. #else
  616. #define QueryServiceConfig  QueryServiceConfigA
  617. #endif // !UNICODE
  618.  
  619. WINADVAPI
  620. BOOL
  621. WINAPI
  622. QueryServiceLockStatusA(
  623.     SC_HANDLE                       hSCManager,
  624.     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
  625.     DWORD                           cbBufSize,
  626.     LPDWORD                         pcbBytesNeeded
  627.     );
  628. WINADVAPI
  629. BOOL
  630. WINAPI
  631. QueryServiceLockStatusW(
  632.     SC_HANDLE                       hSCManager,
  633.     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
  634.     DWORD                           cbBufSize,
  635.     LPDWORD                         pcbBytesNeeded
  636.     );
  637. #ifdef UNICODE
  638. #define QueryServiceLockStatus  QueryServiceLockStatusW
  639. #else
  640. #define QueryServiceLockStatus  QueryServiceLockStatusA
  641. #endif // !UNICODE
  642.  
  643. WINADVAPI
  644. BOOL
  645. WINAPI
  646. QueryServiceObjectSecurity(
  647.     SC_HANDLE               hService,
  648.     SECURITY_INFORMATION    dwSecurityInformation,
  649.     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
  650.     DWORD                   cbBufSize,
  651.     LPDWORD                 pcbBytesNeeded
  652.     );
  653.  
  654. WINADVAPI
  655. BOOL
  656. WINAPI
  657. QueryServiceStatus(
  658.     SC_HANDLE           hService,
  659.     LPSERVICE_STATUS    lpServiceStatus
  660.     );
  661.  
  662. WINADVAPI
  663. SERVICE_STATUS_HANDLE
  664. WINAPI
  665. RegisterServiceCtrlHandlerA(
  666.     LPCSTR             lpServiceName,
  667.     LPHANDLER_FUNCTION   lpHandlerProc
  668.     );
  669. WINADVAPI
  670. SERVICE_STATUS_HANDLE
  671. WINAPI
  672. RegisterServiceCtrlHandlerW(
  673.     LPCWSTR             lpServiceName,
  674.     LPHANDLER_FUNCTION   lpHandlerProc
  675.     );
  676. #ifdef UNICODE
  677. #define RegisterServiceCtrlHandler  RegisterServiceCtrlHandlerW
  678. #else
  679. #define RegisterServiceCtrlHandler  RegisterServiceCtrlHandlerA
  680. #endif // !UNICODE
  681.  
  682. WINADVAPI
  683. BOOL
  684. WINAPI
  685. SetServiceObjectSecurity(
  686.     SC_HANDLE               hService,
  687.     SECURITY_INFORMATION    dwSecurityInformation,
  688.     PSECURITY_DESCRIPTOR    lpSecurityDescriptor
  689.     );
  690.  
  691. WINADVAPI
  692. BOOL
  693. WINAPI
  694. SetServiceStatus(
  695.     SERVICE_STATUS_HANDLE   hServiceStatus,
  696.     LPSERVICE_STATUS        lpServiceStatus
  697.     );
  698.  
  699. WINADVAPI
  700. BOOL
  701. WINAPI
  702. StartServiceCtrlDispatcherA(
  703.     LPSERVICE_TABLE_ENTRYA    lpServiceStartTable
  704.     );
  705. WINADVAPI
  706. BOOL
  707. WINAPI
  708. StartServiceCtrlDispatcherW(
  709.     LPSERVICE_TABLE_ENTRYW    lpServiceStartTable
  710.     );
  711. #ifdef UNICODE
  712. #define StartServiceCtrlDispatcher  StartServiceCtrlDispatcherW
  713. #else
  714. #define StartServiceCtrlDispatcher  StartServiceCtrlDispatcherA
  715. #endif // !UNICODE
  716.  
  717.  
  718. WINADVAPI
  719. BOOL
  720. WINAPI
  721. StartServiceA(
  722.     SC_HANDLE            hService,
  723.     DWORD                dwNumServiceArgs,
  724.     LPCSTR             *lpServiceArgVectors
  725.     );
  726. WINADVAPI
  727. BOOL
  728. WINAPI
  729. StartServiceW(
  730.     SC_HANDLE            hService,
  731.     DWORD                dwNumServiceArgs,
  732.     LPCWSTR             *lpServiceArgVectors
  733.     );
  734. #ifdef UNICODE
  735. #define StartService  StartServiceW
  736. #else
  737. #define StartService  StartServiceA
  738. #endif // !UNICODE
  739.  
  740. WINADVAPI
  741. BOOL
  742. WINAPI
  743. UnlockServiceDatabase(
  744.     SC_LOCK     ScLock
  745.     );
  746.  
  747.  
  748. #ifdef __cplusplus
  749. }
  750. #endif
  751.  
  752. #pragma option -b.
  753. #endif // _WINSVC_
  754.